#!/usr/bin/env python3  /*设定脚本文件直接能执行*/
# -*- coding:utf-8 -*-   /*设置编码*/
"""
@Author: zhuo
@Software: PyCharm
@File: tQtGraphHelper.py
@Time: 2024/10/11 16:03
@Function：pyqtgraph可视化绘图模块
"""
# 导入模块
import os
import numpy as np
from datetime import datetime
# pyqtgraph绘图模块
import pyqtgraph as pg
import pyqtgraph.exporters
from pyqtgraph import InfiniteLine, DateAxisItem
# Qt模块
from PySide6.QtGui import QGuiApplication


class ctQtGraphHelper:
    def __init__(self):
        # 创建GraphicsLayoutWidget对象
        self.pw = pg.GraphicsLayoutWidget(show=False)
        # 创建坐标的标签
        self.pw_label = pg.LabelItem(justify='right')
        # 将坐标添加到GraphicsLayoutWidget布局中来
        self.pw.addItem(self.pw_label)
        # 标签文本及颜色字典
        self.pw_label_text_dict = {}
        self.pw_label_color_dict = {}
        # 设置性能加速函数
        self.__f_setAccelerateFunc(True)
        # 鼠标移动连接标志位（是否显示光标处的值）
        self.mouse_flow_connection = False
        # 鼠标跟随标签、代理、自定义时间刻度(添加完数据点后更新)
        self.label = None
        self.proxy = None
        self.x_ticks = None

    # <editor-fold desc="GraphicsLayoutWidget对象操作函数：【设置背景色函数】">
    # 设置背景色函数
    def f_setBackGroundColorFun(self, color):
        """
        function:  设置背景色函数
              in:  color:需要修改的背景色，例如："#FFFFFF"
             out:  None
          return:  None
          others:  Set Background Color Func
        """
        # 修改背景色
        self.pw.setBackground(color)

    # </editor-fold>

    # <editor-fold desc="X轴默认为时间轴：【添加图例函数】、【曲线数据动态增加函数】">
    # 添加图例函数2
    def f_addGraphFunc2(self, label, row=0, col=0, unit="", color="#1296DB"):
        """
        function:  添加图例(PlotItem图形对象)函数，X轴默认为时间轴
              in:  row:行数（图形对象所在的行数）,默认为0；
                   col:列数（图形对象所在的列数）,默认为0；
                   label:Bottom标签名称；
                   unit:单位，默认为""；
                   color:颜色，默认为"#1296DB"；
             out:  curve:PlotItem图形对象
          others:  Add Graph Legend Func Two
        """
        # 创建带有日期轴的绘图区域 PlotItem图形对象
        curve = self.pw.addPlot(row=row, col=col, axisItems={'bottom': DateAxisItem()})
        # 显示表格线
        curve.showGrid(x=True, y=True)
        # 下采样模式
        curve.setDownsampling(mode='peak')
        # 字体颜色和大小
        label_style = {'color': color, 'font-size': '12pt', "units": unit}
        # 设置底部的label
        curve.setLabel("bottom", label, **label_style)
        # 是否可见
        curve.setClipToView(True)
        # 隐藏PlotItem对象 的 自动缩放按钮“A”(左下角)
        curve.hideButtons()
        # 禁用轴操作
        curve.setMouseEnabled(x=False, y=False)
        # PlotItem图形对象设置X轴范围
        self.f_XAxisAdaptiveFunc(curve)
        # PlotItem图形对象设置Y轴范围
        self.f_YAxisAdaptiveFunc(curve)
        # 返回曲线对象和
        return curve

    # 曲线数据动态增加函数2
    @staticmethod
    def f_addPlotDataFunc2(x_times_list, y_values_list, plot, is_convert=False):
        """
        function:  曲线数据动态增加函数2
              in:  x_times:时间列表，
                   y_values:曲线数据列表；
                   plot:曲线对象PlotDataItem；
                   is_convert:是否需要转换为时间戳，默认为False；
                              如果输入的时间列表已经是完整的，且为时间戳格式，则直接绘图；
                              否则，需要将需要获取当前时间并转换为时间戳，并加入时间戳列表中来，再进行绘图
             out:  x_time_stamps: 返回的时间戳列表
          return:  [datetime.datetime()]，如[datetime.datetime(2025, 2, 27, 17, 56, 1), datetime.datetime(2025, 2, 27, 17, 56, 1)]；
          others:  Curve data increase dynamically
         """
        # 判断是否需要转换为时间戳，也可以理解为是一次性添加还是动态添加
        if is_convert:
            # 获取当前日期和时间
            now = datetime.now()
            # 分解日期和时间
            year = now.year
            month = now.month
            day = now.day
            hour = now.hour
            minute = now.minute
            second = now.second
            # X轴时间列表中添加当前时间
            x_times_list.append(datetime(hour=hour, minute=minute, second=second, year=year, month=month, day=day))
            # 将datetime转换为时间戳（秒）
            x_time_stamps = [dt.timestamp() for dt in x_times_list]
        else:
            x_time_stamps = x_times_list
        # 重新绘制图形
        plot.setData(x_time_stamps, y_values_list)
        # 更新图形
        plot.update()
        return x_time_stamps

    # </editor-fold>

    # <editor-fold desc="X轴为自定义刻度：【添加图例函数】、【曲线数据动态增加函数】、【更新刻度函数】、【恢复刻度函数】">
    # 添加图例函数
    def f_addGraphFunc(self, row, col, label, unit="", color="#1296DB"):
        """
        function:  添加图例(PlotItem图形对象)函数，返回坐标轴X的对象，可对X轴进行自定义操作
              in:  row:行数（图形对象所在的行数）
                   col:列数（图形对象所在的列数）
                   label:标签名称
                   unit:单位
                   color:颜色
             out:  curve:曲线对象
                   xax:坐标轴X
          return:  curve,xax
          others:  Add Graph Legend Func
        """
        # PlotItem图形对象
        curve = self.pw.addPlot(row=row, col=col)
        # 显示表格线
        curve.showGrid(x=True, y=True)
        # 下采样模式
        curve.setDownsampling(mode='peak')
        # 字体颜色和大小
        label_style = {'color': color, 'font-size': '12pt', "units": unit}
        # 设置上下左右的label
        curve.setLabel("bottom", label, **label_style)
        # 1、自定义plotItem坐标轴：获取plotItem的'bottom'轴对象 坐标轴x 获取plotItem的'bottom'轴
        xax = curve.getAxis("bottom")
        # 是否可见
        curve.setClipToView(True)
        # 隐藏PlotItem对象 的 自动缩放按钮“A”(左下角)
        curve.hideButtons()
        # 禁用轴操作
        curve.setMouseEnabled(x=False, y=False)
        # 曲线对象设置X轴范围
        curve.setXRange(0, 10)
        # 曲线对象设置Y轴范围
        curve.setYRange(0, 10)
        # 返回曲线对象和坐标轴X
        return curve, xax

    # 曲线数据动态增加函数
    def f_addPlotDataFunc(self, ptr, lst, curve, plot, x_list, xax, window_mode=False, auto_mode=False):
        """
        function:  曲线数据动态增加：初始的列表为10个，然后10个10个的增加列表的值 ，再赋给曲线
              in:  ptr:曲线指针；
                   lst:曲线数据列表；
                   curve:PlotItem图形对象(画布)；
                   plot:曲线对象PlotDataItem；
                   xLst:刻度值列表，即时间；
                   xax:plotItem的'bottom'对象；
                   window_mode:是否是窗口模式；
                   auto_mode:是否是自动模式；
             out:  None
          return:  int >0 ok, <0 some wrong
          others:  Curve data increase dynamically
         """
        # 先将字符串列表转换为浮点数列表
        lst = [float(x) if isinstance(x, str) else x for x in lst]
        # 3、自定义plotItem坐标轴：刻度值与显示数值绑定 [[(0, '13:52:44'), (1, '13:52:47')]]
        ticks = [list(zip(range(ptr), x_list))]
        self.x_ticks = ticks[0]
        # 如果指针大小 > 温度数据点列表 初始的列表为10个，然后10个10个的增加列表的值 ，再赋给曲线
        if ptr >= len(lst):
            # 获取当前的列表
            p_lst = lst
            # 列表长度+1
            lst = [0 for i in range(len(lst) + 1)]
            # 将之前获取的列表值 赋值给新列表
            lst[:len(p_lst)] = p_lst
        # 4、自定义plotItem坐标轴：设置bottom轴的刻度数值显示
        if auto_mode:
            xax.setTicks(ticks)
        else:
            self.f_updateTicksFunc(curve=curve, x_list=x_list, xax=xax, step_point=6)
        # 重新绘制图形
        plot.setData(lst[:ptr])
        # 判断是否是窗口模式.
        if window_mode:
            # 判断曲线指针是否大于8
            if ptr > 8:
                # 当大于8时，只显示最后8个点
                curve.setXRange(ptr - 8, ptr)
            else:
                curve.setXRange(0, ptr)
        else:
            curve.setXRange(0, ptr)

    # 更新刻度函数
    @staticmethod
    def f_updateTicksFunc(curve, x_list, xax, step_point=10):
        """
        function:  更新刻度函数：通过视图缩放事件动态调整显示的刻度数量
              in:  curve:PlotItem图形对象(画布)
                   xLst:刻度值列表，即时间
                   xax:plotItem的'bottom'对象
                   step_point:每10个点显示一个标签
             out:  None
          return:  None
          others:  Update Ticks Func
        """
        # 获取当前视图范围
        view_range = curve.getViewBox().viewRange()[0]
        x_min, x_max = view_range
        # 计算可见区域内的数据索引
        visible_indices = [i for i, x in enumerate(x_list) if x_min <= i <= x_max]
        # 动态调整步长（每10个点显示一个标签）
        step = max(1, len(visible_indices) // step_point)
        ticks = [(i, x_list[i]) for i in visible_indices[::step]]
        # 设置bottom轴的刻度数值显示
        xax.setTicks([ticks])

    # 恢复刻度函数
    @staticmethod
    def f_recoverTicksFunc(ptr, x_list, xax):
        """
        function:  恢复刻度函数
              in:  ptr:曲线指针；
                   xLst:刻度值列表，即时间；
                   xax:plotItem的'bottom'对象；
             out:  None
          return:  None
          others:  Recover Ticks Func
        """
        # 3、自定义plotItem坐标轴：刻度值与显示数值绑定 [[(0, '13:52:44'), (1, '13:52:47')]]
        ticks = [list(zip(range(ptr), x_list))]
        xax.setTicks(ticks)

    # </editor-fold>

    # <editor-fold desc="保存文件相关函数：【保存图片函数】、【保存svg文件函数】">
    # 保存图片函数
    def f_saveImageFunc(self, path, name):
        """
        function:  保存图片函数
              in:  path:保存路径
                   name:保存名称
             out:  True or False
          return:  bool
          others:  Save Image Func
        """
        # 判断该路径是否存在
        if not os.path.exists(path):
            os.makedirs(path)
        # 创建pyqtgraph.exporters对象
        ex = pg.exporters.ImageExporter(self.pw.scene())
        # 获取当前的主屏幕
        screen = QGuiApplication.primaryScreen()
        screen_width = screen.geometry().width()
        ex.params.param('width').setValue(screen_width)
        # 拼接文件路径
        file_path = f"{path}\\{name}"
        # 调用pyqtgraph.exporters的export方法
        ex.export(file_path)
        # 判断文件是否存在
        if os.path.exists(file_path):
            return True
        return False

    # 保存svg文件函数
    def f_saveSvgFunc(self, path, name):
        """
        function:  保存svg文件函数
              in:  path:保存路径
                   name:保存名称
             out:  True or False
          return:  bool
          others:  Save Svg File Func
        """
        # 判断该路径是否存在
        if not os.path.exists(path):
            os.makedirs(path)
        # 创建pyqtgraph.exporters对象
        ex = pg.exporters.SVGExporter(self.pw.scene())
        # 拼接文件路径
        file_path = f"{path}\\{name}"
        # 调用pyqtgraph.exporters的export方法
        ex.export(file_path)
        # 判断文件是否存在
        if os.path.exists(file_path):
            return True
        return False

    # </editor-fold>

    # <editor-fold desc="鼠标处显示十字线：【设置十字线及标签显示函数】、【添加鼠标跟随函数】、【鼠标移动响应函数】">
    # 设置十字线及标签显示函数
    def f_setInfiniteLineShowFunc(self, curve, is_show):
        """
        function:  设置十字线及标签显示函数
              in:  curve:PlotItem图形对象;
                   is_show:是否显示十字线及标签
             out:  None
          return:  None
          others:  Set Cross Line And Label Show Func
        """
        if is_show:
            for item in curve.items:
                if isinstance(item, InfiniteLine):
                    item.setVisible(True)
            self.pw_label.setVisible(True)
        else:
            for item in curve.items:
                if isinstance(item, InfiniteLine):
                    item.setVisible(False)
            self.pw_label.setVisible(False)

    # 添加鼠标跟随函数
    def f_addMouseFollowFunc(self, curve, plot, show_data_dic):
        """
        function:  添加鼠标跟随函数
              in:  curve:PlotItem图形对象;
                   plot:PlotDataItem曲线对象;
                   show_data_dic:显示数据字典;
             out:  None
          return:  None
          others:  Add Mouse Follow Func
        """
        # 创建曲线上的点
        point = pg.CurvePoint(plot)
        point.setObjectName(plot.objectName())
        # 鼠标跟随的垂直方向的线
        v_line = pg.InfiniteLine(angle=90, movable=False)
        # 鼠标跟随的水平方向的线
        h_line = pg.InfiniteLine(angle=0, movable=False)
        # 创建一个箭头
        # arrow = pg.ArrowItem(angle=90)
        # 将箭头添加到点上
        # arrow.setParentItem(point)  # 将箭头添加到点上
        curve.addItem(v_line, ignoreBounds=True)
        curve.addItem(h_line, ignoreBounds=True)
        # 不含有坐标轴，但有鼠标功能的支持，获取鼠标事件,用户可以使用鼠标缩放/平移 ViewBox 的内容
        vb = curve.vb
        curve.scene().sigMouseMoved.connect(lambda evt: self.__f_mouseMovedFunc(evt,
                                                                                point=point,
                                                                                vb=vb,
                                                                                plot=plot,
                                                                                v_line=v_line,
                                                                                h_line=h_line,
                                                                                show_data_dic=show_data_dic))
        # 初始化标签文本字典
        self.pw_label_text_dict[show_data_dic["name"]] = ""
        # 获取曲线的颜色
        color = show_data_dic["curve"].opts['pen'].color().getRgb()
        # 转换为两位十六进制数，不足时前面补零
        hex_r = format(max(0, min(color[0], 255)), '02x')
        hex_g = format(max(0, min(color[1], 255)), '02x')
        hex_b = format(max(0, min(color[2], 255)), '02x')
        hex_color = f"#{hex_r}{hex_g}{hex_b}"
        self.pw_label_color_dict[show_data_dic["name"]] = hex_color

    # 鼠标移动响应函数
    def __f_mouseMovedFunc(self, evt, point=None, vb=None, plot=None, v_line=None, h_line=None, show_data_dic=None):
        """
        function:  鼠标移动响应函数
              in:  point:曲线上的点;
                   vb:ViewBox视图框;
                   plot:PlotDataItem曲线对象;
                   v_line:鼠标跟随的垂直方向的线;
                   h_line:鼠标跟随的水平方向的线;
                   show_data_dic:显示数据字典;
             out:  None
          return:  None
          others:  Mouse Moved Response Func
        """
        if self.mouse_flow_connection:
            label_text = ""
            try:
                if point is not None and vb is not None and plot is not None:
                    # 更新颜色字典
                    for key, color in self.pw_label_color_dict.items():
                        if key == show_data_dic["name"]:
                            # 获取曲线的颜色
                            color = show_data_dic["curve"].opts['pen'].color().getRgb()
                            # 转换为两位十六进制数，不足时前面补零
                            hex_r = format(max(0, min(color[0], 255)), '02x')
                            hex_g = format(max(0, min(color[1], 255)), '02x')
                            hex_b = format(max(0, min(color[2], 255)), '02x')
                            hex_color = f"#{hex_r}{hex_g}{hex_b}"
                            self.pw_label_color_dict[key] = hex_color
                    # 使用信号代理将原始参数转换为元组，获取事件的鼠标位置
                    pos = evt
                    # 鼠标所处的X轴坐标
                    mouse_point = vb.mapSceneToView(pos)
                    # 如果鼠标位置在绘图部件中
                    # if plot.sceneBoundingRect().contains(pos):
                    # 判断plot是否有大于一个点
                    if show_data_dic["ptr"] > 1:
                        # Point设置位置的float类型范围是0-1
                        point.setPos(
                            mouse_point.x() / (show_data_dic["ptr"] - 1))
                        # 判断曲线是否可见
                        if plot.isVisible():
                            self.pw_label_text_dict[show_data_dic["name"]] = point.pos().y()
                        else:
                            # 解决在隐藏曲线后对应的坐标标签不会隐藏的问题 判断是否不可见，不可见则删除
                            self.pw_label_text_dict.pop(plot.objectName(), None)
                        for key, text in self.pw_label_text_dict.items():
                            # 判断文本是否为空
                            if text != "":
                                hex_color = self.pw_label_color_dict[key]
                                label_text += f"<span style='color: {hex_color}'>{key}:%0.1f  </span>\n" % (
                                    float(text))
                        self.pw_label.setText(label_text)
                        # 设置垂直线的位置
                        v_line.setPos(mouse_point.x())
                        # 设置水平线的位置
                        h_line.setPos(mouse_point.y())
            except Exception as e:
                print(e)

    # </editor-fold>

    # <editor-fold desc="鼠标处显示标签：【添加鼠标跟随函数2】、【鼠标移动响应函数2】">
    # 添加鼠标跟随函数2
    def f_addMouseFollowFunc2(self, curve, plots):
        """
        function:  添加鼠标跟随函数2
              in:  curve:PlotItem图形对象;
                   plots:PlotDataItem曲线对象列表;
             out:  None
          return:  None
          others:  Add Mouse Follow Func Two
        """
        # 创建文本标签
        self.label = pg.TextItem(anchor=(0, 1))
        curve.addItem(self.label)
        self.label.hide()

        # 设置代理
        self.proxy = pg.SignalProxy(
            curve.scene().sigMouseMoved,
            rateLimit=60,
            slot=(lambda evt: self.__f_mouseMovedFunc2(evt, curve=curve, plots=plots))
        )

    # 鼠标移动响应函数2
    def __f_mouseMovedFunc2(self, evt, curve, plots):
        """
        function:  鼠标移动响应函数2
              in:  curve:PlotItem图形对象;
                   plot:PlotDataItem曲线对象列表;
             out:  None
          return:  None
          others:  Mouse Moved Response Func Two
        """
        try:
            if self.mouse_flow_connection:
                pos = evt[0]
                if curve.sceneBoundingRect().contains(pos):
                    view_box = curve.vb
                    mouse_point = view_box.mapSceneToView(pos)
                    min_distance = float('inf')
                    closest_x, closest_y = None, None
                    closest_curve = None
                    mouse_screen_pos = view_box.mapViewToScene(mouse_point)
                    for plot in plots:
                        if plot.isVisible():
                            data = plot.getData()
                            if len(data[0]) == 0:
                                continue
                            idx = np.argmin(np.abs(data[0] - mouse_point.x()))
                            cx, cy = data[0][idx], data[1][idx]
                            # 转换为屏幕坐标
                            point_screen = view_box.mapViewToScene(pg.Point(cx, cy))
                            distance = np.sqrt(
                                (mouse_screen_pos.x() - point_screen.x()) ** 2 +
                                (mouse_screen_pos.y() - point_screen.y()) ** 2
                            )
                            if distance < 10 and distance < min_distance:
                                min_distance = distance
                                closest_x, closest_y = cx, cy
                                closest_curve = plot
                    if closest_curve is not None:
                        # 获取曲线的颜色
                        color = closest_curve.opts.get('pen').color().getRgb()
                        # 转换为两位十六进制数，不足时前面补零
                        hex_r = format(max(0, min(color[0], 255)), '02x')
                        hex_g = format(max(0, min(color[1], 255)), '02x')
                        hex_b = format(max(0, min(color[2], 255)), '02x')
                        hex_color = f"#{hex_r}{hex_g}{hex_b}"
                        # 获取x轴的刻度值（时间）
                        x_text = min(self.x_ticks, key=lambda item: abs(item[0] - closest_x))[1]
                        self.label.setHtml(
                            f"<span style='color: {hex_color}; background-color: #00000080'>"
                            f"{closest_curve.name()}:"
                            f"[{closest_y:.2f}] [{x_text}]"
                            f"</span>"
                        )
                        self.label.setPos(closest_x, closest_y)
                        self.label.show()
                    else:
                        self.label.hide()
                else:
                    self.label.hide()
        except Exception as e:
            print(e)

    # </editor-fold>

    # <editor-fold desc="PlotItem图形对象模式设定函数：【设置自动模式函数】、【设置鼠标模式函数】">
    # 设置自动模式函数
    @staticmethod
    def f_setAutoModeFunc(curve, is_auto):
        """
        function: 设置自动模式函数
              in:  curve:PlotItem图形对象;
                   is_auto:是否自动
             out:  None
          return:  None
          others:  Set Auto Mode Func
        """
        if is_auto:
            curve.showButtons()
            curve.setMouseEnabled(x=True, y=True)
        else:
            curve.hideButtons()
            curve.setMouseEnabled(x=False, y=False)

    # 设置鼠标模式函数
    @staticmethod
    def f_setMouseModeFunc(curve, mode=False):
        """
        function:  设置鼠标模式函数
              in:  curve:PlotItem图形对象(画布)；
                   mode:bool,True为矩形缩放模式，False为平移模式
             out:  None
          return:  None
          others:  Set Mouse Mode Func
        """
        # 获取关联的 ViewBox 并设置鼠标模式
        view_box = curve.getViewBox()
        if mode:
            # 设置为矩形缩放模式
            view_box.setMouseMode(pg.ViewBox.RectMode)
        else:
            # 设置为平移模式
            view_box.setMouseMode(pg.ViewBox.PanMode)

    # </editor-fold>

    # <editor-fold desc="PlotItem图形对象X及Y轴操作函数：【X轴自适应函数】、【Y轴自适应函数】">
    # X轴自适应函数
    @staticmethod
    def f_XAxisAdaptiveFunc(curve):
        """
        function:  X轴自适应函数
              in:  curve:PlotItem图形对象(画布)；
             out:  max_value:可显示曲线中的最大值；
          return:  flout
          others:  X Axis Adaptive Func
        """
        # 启用 X 轴自适应
        curve.enableAutoRange(axis='x', enable=True)

    # Y轴自适应函数
    @staticmethod
    def f_YAxisAdaptiveFunc(curve):
        """
        function:  Y轴自适应函数
              in:  curve:PlotItem图形对象(画布)；
             out:  max_value:可显示曲线中的最大值；
          return:  flout
          others:  Y Axis Adaptive Func
        """
        # 启用 Y 轴自适应
        curve.enableAutoRange(axis='y', enable=True)
        # <editor-fold desc="自定义Y轴自适应的方法">
        # # 用于存储曲线的最大Y值
        # max_values = []
        # # 遍历 PlotItem 中的所有项
        # for item in curve.items:
        #     # 检查是否为 PlotDataItem 类型
        #     if isinstance(item, pg.PlotDataItem):
        #         if item.isVisible():
        #             # 获取X和Y数据
        #             _, y_data = item.getData()
        #             # 检查y_data是否为None
        #             if y_data is None:
        #                 continue
        #             # 找到Y数据中的最大值
        #             max_y_value = max(y_data)
        #             # 将最大值添加到列表中
        #             max_values.append(max_y_value)
        # # 检查max_values是否为空
        # if not max_values:
        #     curve.setYRange(0, 10)
        #     return None  # 默认范围为0到1
        # max_value = max(max_values)
        # curve.setYRange(0, max_value + 1)
        # return max_value
        # </editor-fold>

    # </editor-fold>

    # <editor-fold desc="曲线对象PlotDataItem操作函数：【设置曲线对象隐藏函数】">
    # 设置曲线对象隐藏函数
    @staticmethod
    def f_setPlotVisibleFunc(plot, is_visible):
        """
        function:  设置曲线对象隐藏函数
              in:  plot:曲线对象PlotDataItem;
                   is_visible:是否可见;
             out:  None
          return:  None
          others:  Set Plot Visible Func
        """
        plot.setVisible(is_visible)

    # </editor-fold>

    # <editor-fold desc="性能加速函数：【性能加速函数】">
    # OpenGL性能加速函数
    @staticmethod
    def __f_setAccelerateFunc(is_enable):
        """
        function:  OpenGL性能加速函数
              in:  is_enable:是否开启
             out:  None
          return:  None
          others:  OpenGL performance acceleration function
        """
        if is_enable:
            # 启用 OpenGL 加速
            pg.setConfigOptions(useOpenGL=True)
            # 禁用抗锯齿
            pg.setConfigOptions(antialias=False)
        else:
            # 禁用 OpenGL 加速
            pg.setConfigOptions(useOpenGL=False)
            # 启用抗锯齿
            pg.setConfigOptions(antialias=True)
    # </editor-fold>
